```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>责任链模式深度解析 - 降低系统耦合的优雅方案</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            line-height: 1.8;
            color: #333;
            background-color: #f9f9f9;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #2d3748;
        }
        .hero {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
            color: white;
            position: relative;
            overflow: hidden;
        }
        .hero::before {
            content: '';
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background: url('https://images.unsplash.com/photo-1551288049-bebda4e38f71?ixlib=rb-1.2.1&auto=format&fit=crop&w=1350&q=80') no-repeat center center;
            background-size: cover;
            opacity: 0.15;
            z-index: 0;
        }
        .card {
            background: white;
            border-radius: 12px;
            box-shadow: 0 4px 20px rgba(0,0,0,0.08);
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 25px rgba(0,0,0,0.12);
        }
        .code-block {
            background: #282c34;
            color: #abb2bf;
            border-radius: 8px;
            font-family: 'Courier New', Courier, monospace;
        }
        .feature-icon {
            width: 48px;
            height: 48px;
            display: flex;
            align-items: center;
            justify-content: center;
            border-radius: 50%;
            margin-bottom: 16px;
            color: white;
            font-size: 20px;
        }
        .divider {
            height: 1px;
            background: linear-gradient(90deg, transparent, rgba(0,0,0,0.1), transparent);
            margin: 48px 0;
        }
        .floating-btn {
            position: fixed;
            bottom: 30px;
            right: 30px;
            width: 60px;
            height: 60px;
            border-radius: 50%;
            background: #4f46e5;
            color: white;
            display: flex;
            align-items: center;
            justify-content: center;
            box-shadow: 0 4px 20px rgba(79, 70, 229, 0.3);
            cursor: pointer;
            transition: all 0.3s ease;
            z-index: 100;
        }
        .floating-btn:hover {
            transform: scale(1.1);
            box-shadow: 0 6px 25px rgba(79, 70, 229, 0.4);
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <section class="hero py-20 px-6 relative">
        <div class="container mx-auto max-w-5xl relative z-10">
            <div class="text-center">
                <span class="inline-block px-4 py-1 bg-white bg-opacity-20 rounded-full text-sm font-medium mb-4">设计模式系列</span>
                <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">责任链模式：降低系统耦合的优雅方案</h1>
                <p class="text-xl md:text-2xl opacity-90 max-w-3xl mx-auto mb-8">一种将请求发送者与接收者解耦的行为设计模式，让系统更加灵活可扩展</p>
                <div class="flex justify-center space-x-4">
                    <a href="#intro" class="px-6 py-3 bg-white text-indigo-600 rounded-lg font-medium hover:bg-opacity-90 transition">开始阅读</a>
                    <a href="#examples" class="px-6 py-3 border border-white border-opacity-30 text-white rounded-lg font-medium hover:bg-white hover:bg-opacity-10 transition">应用场景</a>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto max-w-5xl px-6 py-12">
        <!-- Introduction Section -->
        <section id="intro" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-indigo-500 mr-4"></div>
                <h2 class="text-2xl font-bold">责任链模式如何减少模块之间的耦合</h2>
            </div>
            <p class="text-lg text-gray-700 mb-6">在复杂的软件系统中，模块之间的耦合是一个常见的问题。高耦合的代码不仅增加了维护成本，还会导致系统的扩展性和灵活性受限。当我们需要为不同的请求设计灵活的处理逻辑时，传统的硬编码方式会将请求的发送者与处理逻辑紧密绑定，导致代码难以适应需求的变化。在这种背景下，<span class="font-bold text-indigo-600">责任链模式</span>提供了一种优雅的解决方案。</p>
            
            <div class="card p-6 mb-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1733901258394-9bc75936-4ef6-4e62-bead-c4da029f0813.png" alt="责任链模式示意图" class="w-full rounded-lg mb-4">
                <p class="text-gray-600">责任链模式通过将请求沿着一个"责任链"传递，使多个对象都有机会处理该请求。请求的发送者不需要知道谁会处理它，处理逻辑由链上的处理者动态决定。这种模式将"请求的发送"与"请求的处理"解耦，每个处理者专注于自己的职责，避免了模块间的直接依赖。例如，在一个企业审批流程中，不同级别的审批人员可能会处理不同类型的请求，而使用责任链模式，审批流程的动态调整只需要改变链条的顺序，无需修改核心业务逻辑。</p>
            </div>
        </section>

        <!-- Definition Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-indigo-500 mr-4"></div>
                <h2 class="text-2xl font-bold">责任链模式的定义</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div class="card p-6">
                    <h3 class="text-xl font-bold mb-4 text-indigo-600">1. 核心定义</h3>
                    <p class="mb-4">责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它通过将请求沿着一个职责链（责任链）传递，使得多个对象都有机会处理该请求，而请求的发送者不需要明确指定接收者。请求会沿链条依次传递，直到某个对象处理它或者链的末尾。</p>
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1733901291430-df604ed0-8bc5-4dcb-bf8e-0119a4766769.png" alt="责任链模式核心定义" class="w-full rounded-lg">
                </div>

                <div class="card p-6">
                    <h3 class="text-xl font-bold mb-4 text-indigo-600">2. 核心思想</h3>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span>将请求的发送者和处理者解耦，使得发送者不需要关心处理者的具体实现。</span>
                        </li>
                        <li class="flex items-start">
                            <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                            <span>责任链由多个处理者组成，每个处理者负责特定的任务或条件判断，当当前处理者无法处理请求时，它将请求转交给下一个处理者。</span>
                        </li>
                    </ul>

                    <h3 class="text-xl font-bold mt-8 mb-4 text-indigo-600">3. 责任链模式的组成</h3>
                    <div class="space-y-4">
                        <div>
                            <h4 class="font-bold">抽象处理者（Handler）</h4>
                            <p class="text-sm text-gray-600">定义一个处理请求的接口或抽象类。提供设置下一个处理者的功能。</p>
                        </div>
                        <div>
                            <h4 class="font-bold">具体处理者（ConcreteHandler）</h4>
                            <p class="text-sm text-gray-600">实现处理逻辑。决定是否自己处理请求或者将请求传递给下一个处理者。</p>
                        </div>
                        <div>
                            <h4 class="font-bold">客户端（Client）</h4>
                            <p class="text-sm text-gray-600">创建请求并将其提交到责任链的起点。</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Structure Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-indigo-500 mr-4"></div>
                <h2 class="text-2xl font-bold">责任链模式的结构</h2>
            </div>

            <p class="text-lg text-gray-700 mb-6">责任链模式的核心在于将一组具有相同接口的处理者（Handler）链接成一个链条，使请求能够沿着链条传递，直到被某个处理者处理或到达链尾。其结构设计强调模块间的职责分离与动态组合。</p>

            <div class="card p-6 mb-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1733901329464-81a69d68-2196-461e-97ea-679561dd6f48.png" alt="责任链模式结构图" class="w-full rounded-lg mb-4">
                <h3 class="text-xl font-bold mb-4 text-indigo-600">1. 抽象处理者（Handler）</h3>
                <ul class="list-disc pl-6 mb-6 space-y-2">
                    <li><span class="font-medium">定义职责链中的基础元素：</span>抽象处理者是责任链的核心接口或抽象类，定义了一个处理请求的接口以及设置或调用下一个处理者的方法。</li>
                    <li><span class="font-medium">职责：</span>提供统一的方法来处理请求；保存下一个处理者的引用，形成链式结构；实现链的递归调用机制。</li>
                </ul>

                <h4 class="font-bold mb-2">示例代码：</h4>
                <div class="code-block p-4 rounded-lg mb-6 overflow-x-auto">
                    <pre class="text-sm"><code>public abstract class Handler {
    protected Handler next; // 下一个处理者

    public void setNext(Handler next) {
        this.next = next;
    }

    public abstract void handleRequest(String request);
}</code></pre>
                </div>

                <h3 class="text-xl font-bold mb-4 text-indigo-600">2. 具体处理者（ConcreteHandler）</h3>
                <ul class="list-disc pl-6 mb-6 space-y-2">
                    <li><span class="font-medium">实现具体的处理逻辑：</span>每个具体处理者负责处理特定类型的请求，或者决定是否将请求传递给下一个处理者。</li>
                    <li><span class="font-medium">职责：</span>对请求的条件进行判断；实现具体的业务逻辑；在不能处理时，将请求传递给下一个处理者。</li>
                </ul>

                <h4 class="font-bold mb-2">示例代码：</h4>
                <div class="code-block p-4 rounded-lg mb-6 overflow-x-auto">
                    <pre class="text-sm"><code>public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("A".equals(request)) {
            System.out.println("Handler A 处理了请求");
        } else if (next != null) {
            next.handleRequest(request);
        }
    }
}</code></pre>
                </div>

                <h3 class="text-xl font-bold mb-4 text-indigo-600">3. 客户端（Client）</h3>
                <ul class="list-disc pl-6 mb-6 space-y-2">
                    <li><span class="font-medium">发起请求并构建责任链：</span>客户端是责任链的入口，负责创建具体的处理者对象并将它们串联成链。</li>
                    <li><span class="font-medium">职责：</span>创建责任链的处理者实例；设置链条顺序；向责任链发送请求。</li>
                </ul>

                <h4 class="font-bold mb-2">示例代码：</h4>
                <div class="code-block p-4 rounded-lg mb-6 overflow-x-auto">
                    <pre class="text-sm"><code>public class Client {
    public static void main(String[] args) {
        // 创建处理者
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        // 构建责任链
        handlerA.setNext(handlerB);

        // 发起请求
        handlerA.handleRequest("A");
        handlerA.handleRequest("B");
    }
}</code></pre>
                </div>
            </div>
        </section>

        <!-- Benefits Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-indigo-500 mr-4"></div>
                <h2 class="text-2xl font-bold">责任链模式的优点</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-8">
                <div class="card p-6">
                    <div class="feature-icon bg-indigo-500">
                        <i class="fas fa-link"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">降低模块之间的耦合</h3>
                    <p class="text-gray-600">请求的发送者与接收者解耦，发送者无需知道具体是哪个对象处理请求。处理者之间的职责划分清晰，链条的实现细节对调用方透明。</p>
                </div>

                <div class="card p-6">
                    <div class="feature-icon bg-green-500">
                        <i class="fas fa-random"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">提高系统的灵活性</h3>
                    <p class="text-gray-600">可以根据需求动态地调整链条中的处理者或链条顺序，而不需要修改已有代码。责任链可以通过组合模式实现灵活的运行时行为。</p>
                </div>

                <div class="card p-6">
                    <div class="feature-icon bg-blue-500">
                        <i class="fas fa-expand"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">符合开闭原则</h3>
                    <p class="text-gray-600">新增或修改处理逻辑时，可以通过新增处理者或调整链条结构实现，而无需修改现有处理者代码。责任链的实现避免了复杂的 if-else 或 switch 判断逻辑。</p>
                </div>

                <div class="card p-6">
                    <div class="feature-icon bg-purple-500">
                        <i class="fas fa-tools"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">易于扩展和维护</h3>
                    <p class="text-gray-600">每个处理者只专注于其职责范围内的逻辑，实现了职责单一化，便于开发和维护。代码的可读性和可维护性增强，减少了因逻辑交叉导致的复杂度。</p>
                </div>
            </div>
        </section>

        <!-- Use Cases Section -->
        <section id="examples" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-indigo-500 mr-4"></div>
                <h2 class="text-2xl font-bold">适用场景</h2>
            </div>

            <div class="grid md:grid-cols-2 gap-6">
                <div class="card p-6">
                    <div class="flex items-start">
                        <div class="bg-indigo-100 text-indigo-600 p-3 rounded-lg mr-4">
                            <i class="fas fa-file-signature text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-lg font-bold mb-2">审批流程</h3>
                            <p class="text-gray-600">在企业中，常见的审批流程通常有多个级别（如部门经理审批、总经理审批）。可以将每一级审批定义为责任链中的一个处理者，审批请求沿着链条传递，直至满足审批条件。</p>
                        </div>
                    </div>
                </div>

                <div class="card p-6">
                    <div class="flex items-start">
                        <div class="bg-green-100 text-green-600 p-3 rounded-lg mr-4">
                            <i class="fas fa-user-shield text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-lg font-bold mb-2">权限校验</h3>
                            <p class="text-gray-600">在权限管理系统中，用户权限需要逐级检查。每个处理者负责校验一部分权限，链条终止于校验通过或权限不足。</p>
                        </div>
                    </div>
                </div>

                <div class="card p-6">
                    <div class="flex items-start">
                        <div class="bg-blue-100 text-blue-600 p-3 rounded-lg mr-4">
                            <i class="fas fa-clipboard-list text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-lg font-bold mb-2">日志处理</h3>
                            <p class="text-gray-600">系统中不同的日志需要不同的记录方式（如控制台输出、文件记录、远程服务器记录）。日志信息沿着链条传递，每个处理者判断是否需要处理。</p>
                        </div>
                    </div>
                </div>

                <div class="card p-6">
                    <div class="flex items-start">
                        <div class="bg-purple-100 text-purple-600 p-3 rounded-lg mr-4">
                            <i class="fas fa-envelope-open-text text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-lg font-bold mb-2">消息分发</h3>
                            <p class="text-gray-600">系统接收到用户请求或事件后，需要根据消息类型将其分发到对应的处理模块。每个模块判断是否能处理该消息，如果不能处理则交给下一个模块。</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Diagram Section -->
        <section class="mb-20">
            <div class="card p-6">
                <h3 class="text-xl font-bold mb-6 text-center">责任链模式结构图</h3>
                <div class="mermaid">
                    classDiagram
                        class Handler {
                            <<abstract>>
                            +Handler next
                            +setNext(Handler next)
                            +handleRequest(String request)
                        }
                        
                        class ConcreteHandlerA {
                            +handleRequest(String request)
                        }
                        
                        class ConcreteHandlerB {
                            +handleRequest(String request)
                        }
                        
                        class Client {
                            +main(String[] args)
                        }
                        
                        Handler <|-- ConcreteHandlerA
                        Handler <|-- ConcreteHandlerB
                        Handler o-- Handler : next
                        Client ..> Handler : uses
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-12">
        <div class="container mx-auto max-w-5xl px-6">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold">技术小馆</h3>
                    <p class="text-gray-400 mt-1">探索编程之美，分享技术精华</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-indigo-300 hover:text-white transition duration-300">http://www.yuque.com/jtostring</a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-gray-400 text-sm">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <!-- Floating Button -->
    <div class="floating-btn" id="backToTop">
        <i class="fas fa-arrow-up"></i>
    </div>

    <script>
        // Initialize Mermaid
        mermaid.initialize({
            startOnLoad: true,
            theme: 'dark',
            flowchart: {
                useMaxWidth: false,
                htmlLabels: true
            }
        });

        // Back to top button
        document.getElementById('backToTop').addEventListener('click', () => {
            window.scrollTo({
                top: 0,
                behavior: 'smooth'
            });
        });

        // Show/hide back to top button
        window.addEventListener('scroll', () => {
            const backToTop = document.getElementById('backToTop');
            if (window.pageYOffset > 300) {
                backToTop.style.opacity = '1';
                backToTop.style.visibility = 'visible';
            } else {
                backToTop.style.opacity = '0';
                backToTop.style.visibility = 'hidden';
            }
        });
    </script>
</body>
</html>
```